doc/Langauge/16 - Introduction to File Handling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# File Handling\n",
    "\n",
    "So far, we have worked with the objects in Primary Memory. However Primary Memory is volatile. In order to save the current state of program, objects for future use, we have to save it in Secondary Memory. It is achieved via file handling.\n",
    "\n",
    "## Opening Files\n",
    "\n",
    "`open()` returns a file object, and is most commonly used with two arguments: `open(filename, mode)`. `mode` is a string that determines how the file should be opened.\n",
    "Normally, files are opened in text mode, that means, you read and write strings from and to the file, which are encoded in a specific encoding. If encoding is not specified, the default is platform dependent (see open()). 'b' appended to the mode opens the file in binary mode: now the data is read and written in the form of bytes objects. This mode should be used for all files that don’t contain text.\n",
    "\n",
    "\n",
    "- `r` - Read\n",
    "- `w` - Write\n",
    "- `a` - Append\n",
    "- `r+` - Read and Write, similarly `w+` and `a+`\n",
    "\n",
    "If no mode is specified, it is defaulted to `r`\n",
    "\n",
    "Normally, files are opened in _text mode_, that means, you read and write strings from and to the file, which are encoded in a specific encoding. If encoding is not specified, the default is platform dependent. `'b'` appended to the mode opens the file in binary mode: now the data is read and written in the form of bytes objects. This mode should be used for all files that don’t contain text.\n",
    "\n",
    "It is good practice to use the `with` keyword when dealing with file objects. The advantage is that the file is properly closed after its suite finishes, even if an exception is raised at some point. Using with is also much shorter than writing equivalent try-finally blocks:\n",
    "\n",
    "```python\n",
    "    >>> with open('workfile') as f:\n",
    "    ...     read_data = f.read()\n",
    "    >>> f.closed\n",
    "    True\n",
    "```\n",
    "\n",
    "If you’re not using the `with` keyword, then you should call `f.close()` to close the file and immediately free up any system resources used by it. If you don’t explicitly close a file, Python’s garbage collector will eventually destroy the object and close the open file for you, but the file may stay open for a while. Another risk is that different Python implementations will do this clean-up at different times.\n",
    "\n",
    "After a file object is closed, either by a with statement or by calling `f.close()`, attempts to use the file object will automatically fail.\n",
    "\n",
    "\n",
    "```python\n",
    "    >>> f.close()\n",
    "    >>> f.read()\n",
    "    Traceback (most recent call last):\n",
    "      File \"<stdin>\", line 1, in <module>\n",
    "    ValueError: I/O operation on closed file\n",
    "```\n",
    "\n",
    "## Methods of File Objects\n",
    "\n",
    "The rest of the examples in this section will assume that a file object called `f` has already been created.\n",
    "\n",
    "To read a file’s contents, call `f.read(size)`, which reads some quantity of data and returns it as a string (in text mode) or bytes object (in binary mode). `size` is an optional numeric argument. When size is omitted or negative, the entire contents of the file will be read and returned; it’s your problem if the file is twice as large as your machine’s memory. Otherwise, at most size bytes are read and returned. If the end of the file has been reached, `f.read()` will return an empty string (`''`).\n",
    "\n",
    "\n",
    "```python\n",
    "    >>>\n",
    "    >>> f.read()\n",
    "    'This is the entire file.\\n'\n",
    "    >>> f.read()\n",
    "    ''\n",
    "```\n",
    "\n",
    "`f.readline()` reads a single line from the file; a newline character (`\\n`) is left at the end of the string, and is only omitted on the last line of the file if the file doesn’t end in a newline. This makes the return value unambiguous; if `f.readline()` returns an empty string, the end of the file has been reached, while a blank line is represented by '`\\n`', a string containing only a single newline.\n",
    "\n",
    "```python\n",
    "    >>>\n",
    "    >>> f.readline()\n",
    "    'This is the first line of the file.\\n'\n",
    "    >>> f.readline()\n",
    "    'Second line of the file\\n'\n",
    "    >>> f.readline()\n",
    "    ''\n",
    "```\n",
    "\n",
    "For reading lines from a file, you can loop over the file object. This is memory efficient, fast, and leads to simple code:\n",
    "\n",
    "```python\n",
    "    >>>\n",
    "    >>> for line in f:\n",
    "    ...     print(line, end='')\n",
    "    ...\n",
    "    This is the first line of the file.\n",
    "    Second line of the file\n",
    "```\n",
    "\n",
    "If you want to read all the lines of a file in a list you can also use `list(f)` or `.readlines()`.\n",
    "\n",
    "`f.write(string)` writes the contents of string to the file, returning the number of characters written.\n",
    "\n",
    "```python\n",
    "    >>>\n",
    "    >>> f.write('This is a test\\n')\n",
    "    15\n",
    "```\n",
    "\n",
    "Other types of objects need to be converted – either to a string (in text mode) or a bytes object (in binary mode) – before writing them:\n",
    "\n",
    "```python\n",
    "    >>>\n",
    "    >>> value = ('the answer', 42)\n",
    "    >>> s = str(value)  # convert the tuple to string\n",
    "    >>> f.write(s)\n",
    "    18\n",
    "```\n",
    "`f.tell()` returns an integer giving the file object’s current position in the file represented as number of bytes from the beginning of the file when in binary mode and an opaque number when in text mode.\n",
    "\n",
    "To change the file object’s position, use `f.seek(offset, from_what)`. The position is computed from adding offset to a reference point; the reference point is selected by the `from_what` argument. A from_what value of `0` measures from the beginning of the file, `1` uses the current file position, and `2` uses the end of the file as the reference point. `from_what` can be omitted and defaults to 0, using the beginning of the file as the reference point.\n",
    "\n",
    "```python\n",
    "    >>>\n",
    "    >>> f = open('workfile', 'rb+')\n",
    "    >>> f.write(b'0123456789abcdef')\n",
    "    16\n",
    "    >>> f.seek(5)      # Go to the 6th byte in the file\n",
    "    5\n",
    "    >>> f.read(1)\n",
    "    b'5'\n",
    "    >>> f.seek(-3, 2)  # Go to the 3rd byte before the end\n",
    "    13\n",
    "    >>> f.read(1)\n",
    "    b'd'\n",
    "```\n",
    "In text files (those opened without a `b` in the mode string), only seeks relative to the beginning of the file are allowed (the exception being seeking to the very file end with `seek(0, 2)`) and the only valid offset values are those returned from the `f.tell()`, or zero. Any other offset value produces undefined behaviour.\n",
    "\n",
    "File objects have some additional methods, such as `isatty()` and `truncate()` which are less frequently used; consult the Library Reference for a complete guide to file objects.\n",
    "\n",
    "----\n",
    "**Note** : This chapter is copied from [Python Reference](https://docs.python.org/3/tutorial/inputoutput.html)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}